home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / ultra250.zip / UW_HELP3.HLP < prev    next >
Text File  |  1992-11-03  |  23KB  |  666 lines
  1. `co(4,7);──────────────────────── /// The Keyboard/Mouse ──────────────────────────────`co();
  2.  
  3.  ┌──────────────────────────────────────────────────────────────────────────┐    
  4.  │        `keyword(init_mouse,/// init_mouse);              `keyword(end_mouse ,/// end_mouse);            `keyword(m_reset     ,/// m_reset);        │
  5.  │        `keyword(set_idle_func,/// set_idle_func);           `keyword(set_key_func,/// set_key_func);          `keyword(get_key     ,/// get_key);        │
  6.  │        `keyword(wait_event,/// wait_event);              `keyword(event_pending,/// event_pending);         `keyword(m_pos    ,/// m_pos);           │
  7.  │        `keyword(wait_ticks,/// wait_ticks);              `keyword(check_key ,/// check_key);            `keyword(m_released  ,/// m_released);        │
  8.  │        `keyword(m_hide,/// m_hide);                  `keyword(m_show    ,/// m_show);            `keyword(m_motion     ,/// m_motion);       │
  9.  │        `keyword(m_moveto,/// m_moveto);                `keyword(m_pressed ,/// m_pressed);            `keyword(m_ratio      ,/// m_ratio);       │
  10.  │        `keyword(m_colrange,/// m_colrange);              `keyword(m_rowrange,/// m_rowrange);                                │
  11.  │        `keyword(m_lpen_on,/// m_lpen_on);               `keyword(m_lpen_off,/// m_lpen_off);                                │
  12.  └──────────────────────────────────────────────────────────────────────────┘
  13.  
  14.         The UltraWin library interfaces to the user through either the keyboard,
  15.     mouse, or both.  The keyboard routines support all possible key presses
  16.     which include left and right Shift, Alt, and Ctrl key combinations.  The
  17.     mouse routines allow complete control of a two or three button mouse, and
  18.     is Microsoft driver compatible.    The event routines handle detecting both
  19.     mouse and keyboard presses for you, so making your programs support a
  20.     mouse is a snap!  In addition, UltraWin allows you to define your own
  21.     background function, which is called any place in the library that waits
  22.     for user input.  This allows you to write your own processing routines to
  23.     be performed in the background, then call one function to notify the
  24.     library of your routine, then just forget all about it!  Refer to the
  25.     set_idle_func and wait_event functions for details.
  26.  
  27. `co(10,1);/// init_mouse`co();   `keyword(source,[UW_EVENT.C]~init_mouse);
  28.         Call this function just after init_video or force_video if you wish to
  29.     use the mouse in your program.  If the mouse is connected and a driver is
  30.     installed, then the global variable Mouse_exists is set to TRUE (1). In
  31.     addition the mouse cursor column and row ranges are set to cover the
  32.     entire text screen.    After calling this function you may show the mouse on
  33.     the screen using the function m_show.
  34.  
  35. Prototype:
  36.     void init_mouse(void);
  37.  
  38. Parameters:
  39.     None.
  40.  
  41. Usage:
  42.     init_mouse();
  43.  
  44. `co(10,1);/// end_mouse`co();   `keyword(source,[UW_EVENT.C]~end_mouse);
  45.         If the mouse was found to be present in init_mouse, this function turns
  46.     the mouse back off.  This keeps the mouse from being active at the DOS
  47.     prompt.  Call this prior to exiting your program if your program called
  48.     init_mouse or the lower level m_reset function.
  49.  
  50. Prototype:
  51.     void end_mouse(void);
  52.  
  53. Parameters:
  54.     None.
  55.  
  56. Usage:
  57.     end_mouse();
  58.  
  59. `co(10,1);/// m_reset`co();   `keyword(source,[UW_EVENT.C]~m_reset);
  60.         This is the lower level function called by both init_mouse and
  61.     end_mouse. It is used both to determine if the mouse exists, and also to
  62.     reset the mouse prior to program exit.
  63.     
  64. Prototype:
  65.     void m_reset(M_RESET *m)
  66.  
  67. Parameters:
  68. `co(11,1);    M_RESET *m`co();
  69.         A variable of type M_RESET.  Refer to the structures/globals topic for
  70.         information on the members of this structure.
  71.  
  72. Usage:
  73.     M_RESET m;
  74.     ...
  75.     m_reset(&m);
  76.  
  77. `co(10,1);/// set_idle_func`co();   `keyword(source,[UW_EVENT.C]~set_idle_func);
  78.         Allows you to define your own background process. Simply write your own
  79.     C function, keeping in mind that to remain responsive to the keyboard you
  80.     should keep your code tight and fast.  Then call set_idle_func with the
  81.     pointer to your function.
  82.  
  83. Prototype:
  84.     void set_idle_func( int (*func_ptr)(void) );
  85.  
  86. Parameters:
  87. `co(11,1);    int (*func_ptr)(void)`co();
  88.         A pointer to the function you wish to install as the idle function.
  89.         
  90. Usage:
  91.     process()
  92.     {
  93.         ...
  94.     }
  95.     ...
  96.     set_idle_func( process );
  97.  
  98. `co(10,1);/// wait_event`co();   `keyword(source,[UW_EVENT.C]~wait_event);
  99.         Waits until either a key is pressed, or a mouse button is clicked.    The
  100.     global variable Event will contain the information about the event.    If it
  101.     is a keyboard event, the key or combination of keys pressed is saved.  If
  102.     a mouse event, then the button that was pressed, how many times it was
  103.     pressed, and the x and y coordinate at which the press occurred is saved.
  104.  
  105.         While UltraWin waits for user input, it is free to perform background
  106.     processing.    If a user defined function has been installed with
  107.     set_idle_func, that function will be called during idle time.
  108.     
  109. Prototype:
  110.     void wait_event(void);
  111.  
  112. Parameters:
  113.     None.
  114.  
  115. Usage:
  116.     wait_event();
  117.  
  118. `co(10,1);/// event_pending`co();   `keyword(source,[UW_EVENT.C]~event_pending);
  119.         Checks for an event, and returns TRUE (1) if an event has occurred or
  120.     FALSE (0) if no event has occurred.    If an event has occurred, then the
  121.     information about the event, which includes the event type (keyboard or
  122.     mouse), the key and modifier, or the mouse location and button status is
  123.     returned in the global Event variable.  Refer to `keyword(Structures/Globals,[uw_help1.hlp]/// Structures/Globals); for
  124.     information about the EVENT structure and member names for extracting
  125.     this information.
  126.  
  127. Prototype:
  128.     int event_pending(void);
  129.  
  130. Parameters:
  131.     None.
  132.  
  133. Usage:
  134.     int status;
  135.     ...
  136.     status = event_pending();
  137.  
  138. `co(10,1);/// wait_ticks`co();   `keyword(source,[UW_EVENT.C]~wait_event);
  139.         Waits for a given number of system ticks.    There are 18.2 system ticks
  140.     per second.  If you have defined a background process with the
  141.     set_idle_func function, it will call your process function while it waits
  142.     for the given ticks to pass.  UltraWin now has enhanced timer support.
  143.     See `keyword(Timer/Sound Support,[uw_help6.hlp]/// Timer/Sound Support); for further details.
  144.     
  145. Prototype:
  146.     void wait_ticks( clock_t ticks );
  147.  
  148. Parameters:
  149. `co(11,1);    int ticks`co();
  150.         The number of system ticks to wait.  Be sure to pass this as a long or
  151.         cast your number to a clock_t.
  152.  
  153. Usage:
  154.     wait_ticks( 9L );
  155.     wait_ticks( (clock_t) 37 );
  156.  
  157. `co(10,1);/// check_key`co();   `keyword(source,[UW_EVENT.C]~check_key);
  158.         Checks to see if a key has been pressed, and returns the key without
  159.     pulling it out of the keyboard buffer.  The key value is returned (see
  160.     UW_KEYS.H for key defines).  If no key has been pressed, then check_key
  161.     will return FALSE (0).
  162.       You can "capture" any key by installing a function that is called by
  163.     check_key.  This is set by calling `keyword(set_key_func,/// set_key_func);.  Check key will
  164.     pass this function the key and modifier.  When the called function
  165.     returns, if 1 is returned, check_key acts as though no key was ever
  166.     hit, if a 0 is returned, the key is then passed through.  This is a
  167.     very useful, low-level way to supply "hot-keys" anywhere in your
  168.     program, even while entering data!
  169.  
  170. Prototype:
  171.     int check_key(void);
  172.  
  173. Parameters:
  174.     None.
  175.  
  176. Usage:
  177.     int key;
  178.     ...
  179.     key = check_key();
  180.  
  181. `co(10,1);/// set_key_func`co();   `keyword(source,[UW_EVENT.C]~set_key_func);
  182.         Allows you to define your own "hotkey" function. Simply write your own
  183.     "C" function, keeping in mind that to remain responsive to the keyboard you
  184.     should keep your code tight and fast.  Then call set_key_func with the
  185.     pointer to your function.  Your function is passed the key and key
  186.     modifier.  See `keyword(check_key,/// check_key); for more details.
  187.  
  188. Prototype:
  189.     void set_key_func( int (*func_ptr)(int, int) );
  190.  
  191. Parameters:
  192. `co(11,1);    int (*func_ptr)(int, int)`co();
  193.         A pointer to the function you wish to install as the key function.
  194.         
  195. Usage:
  196.     process(int key, int mod)
  197.     {
  198.         ...
  199.     }
  200.     ...
  201.     set_key_func( process );
  202.  
  203. `co(10,1);/// get_key`co();   `keyword(source,[UW_EVENT.C]~get_key);
  204.         Waits until a key has been pressed, and returns the key value (see
  205.     UW_KEYS.H for key defines).
  206.  
  207. Prototype:
  208.     int get_key();
  209.  
  210. Parameters:
  211.     None.
  212.  
  213. Usage:
  214.     int key;
  215.     ...
  216.     key = get_key();
  217.  
  218. `co(10,1);/// m_hide`co();   `keyword(source,[UW_EVENT.C]~m_hide);
  219.         Hides the mouse cursor.  Call this function to remove the mouse cursor
  220.     temporarily from the screen when you are doing window output. Call the
  221.     m_show function after your window output to put the cursor back on the
  222.     screen.
  223.  
  224.         NOTE: Even though the mouse is not shown on the screen, the cursor will
  225.     still track with the mouse, and mouse buttons are still active.
  226.  
  227. Prototype:
  228.     void m_hide(void);
  229.  
  230. Parameters:
  231.     None.
  232.  
  233. Usage:
  234.     m_hide();
  235.  
  236. `co(10,1);/// m_show`co();   `keyword(source,[UW_EVENT.C]~m_show);
  237.     Shows the mouse cursor.    This is used to undo the affect of m_hide.
  238.  
  239. Prototype:
  240.     void m_show(void);
  241.  
  242. Parameters:
  243.     None.
  244.  
  245. Usage:
  246.     m_show();
  247.  
  248. `co(10,1);/// m_pos`co();   `keyword(source,[UW_EVENT.C]~m_pos);
  249.         Gets the current location of the mouse, as well as the status of the
  250.     buttons.
  251.  
  252. Prototype:
  253.     void m_pos( M_LOC *m )
  254.  
  255. Parameters:
  256. `co(11,1);    M_LOC *m`co();
  257.         A pointer to a variable of type M_LOC that contains the position and
  258.         button status information.    Refer to the structures/globals topic above
  259.         for information about the M_LOC structure.
  260.  
  261. Usage:
  262.     M_LOC m;
  263.     ...
  264.     m_pos( &m );
  265.  
  266. `co(10,1);/// m_moveto`co();   `keyword(source,[UW_EVENT.C]~m_moveto);
  267.         Moves the mouse to the position specified by column and row.
  268.  
  269. Prototype:
  270.     void m_moveto( int col, int row );
  271.  
  272. Parameters:
  273. `co(11,1);    int col, row`co();
  274.         The column and row at which the mouse cursor is to be placed.
  275.  
  276. Usage:
  277.     m_moveto( 10, 25 );
  278.  
  279. `co(10,1);/// m_pressed`co();   `keyword(source,[UW_EVENT.C]~m_pressed);
  280.         Checks to see if the button passed has been pressed since the last call
  281.     to this function, and return the button count (number of clicks) and the
  282.     location where the click occurred. A press has occurred when the M_LOC
  283.     count member is greater than 0.
  284.  
  285. Prototype:
  286.     void m_pressed( int button, M_LOC *m );
  287.  
  288. Parameters:
  289. `co(11,1);    int button`co();
  290.         The button to test for being pressed.  This can be one of the defines
  291.         (in UW.H) LB, MB, or RB.
  292. `co(11,1);    M_LOC *m`co();
  293.         A pointer to a variable of type M_LOC that the function will use to
  294.         place the position and button status information.
  295.  
  296. Usage:
  297.     M_LOC m;
  298.     ...
  299.     m_pressed( LB, &m );
  300.  
  301. `co(10,1);/// m_released`co();   `keyword(source,[UW_EVENT.C]~m_released);
  302.         Performs the same function as m_pressed, but is used to test when the
  303.     mouse button is released.
  304.  
  305. Prototype:
  306.     void m_released( int button, M_LOC *m );
  307.  
  308. Parameters:
  309. `co(11,1);    int button`co();
  310.         The button to test for being released.    This can be one of the defines
  311.         (in UW.H) LB, MB, or RB.
  312. `co(11,1);    M_LOC *m`co();
  313.         A pointer to a variable of type M_LOC that the function will use to
  314.         place the position and button status information.
  315.  
  316. Usage:
  317.     M_LOC m;
  318.     ...
  319.     m_released( LB, &m );
  320.  
  321. `co(10,1);/// m_colrange`co();   `keyword(source,[UW_EVENT.C]~m_colrange);
  322.         Allows you to set the range of columns that the mouse will be allowed to
  323.     move within.  Typically this will be from 0 to V_cols-1, but you may set
  324.     it to a range less than this if you wish to keep the mouse inside a
  325.     subrange of the screen.
  326.  
  327. Prototype:
  328.     void m_colrange( int col_min, int col_max );
  329.  
  330. Parameters:
  331. `co(11,1);    int col_min, col_max`co();
  332.         The column mininum and maximum values.
  333.  
  334. Usage:
  335.     m_colrange( 0, V_cols );
  336.  
  337. `co(10,1);/// m_rowrange`co();   `keyword(source,[UW_EVENT.C]~m_rowrange);
  338.         Is the complement to m_colrange.     Typically this will be from 0 to
  339.     V_rows-1, but like m_colrange you may set it to a range less than this if
  340.     you wish to keep the mouse inside a subrange of the screen.
  341.  
  342. Prototype:
  343.     void m_rowrange( int row_min, int row_max );
  344.  
  345. Parameters:
  346. `co(11,1);    int row_min, row_max`co();
  347.         The row mininum and maximum values.
  348.  
  349. Usage:
  350.     m_rowrange( 0, V_rows );
  351.  
  352. `co(10,1);/// m_motion`co();   `keyword(source,[UW_EVENT.C]~m_motion);
  353.         Reports the net motion of cursor since last call to this function. A
  354.     pointer to a variable of type M_MOVE is used to pass back the information.
  355.  
  356. Prototype:
  357.     void m_motion( M_MOVE *m );
  358.  
  359. Parameters:
  360. `co(11,1);    M_MOVE *m`co();
  361.         A pointer to a variable of type M_MOVE.  See `keyword(Structures/Globals,[uw_help1.hlp]/// Structures/Globals); for
  362.         information on the M_MOVE members.
  363.  
  364. Usage:
  365.     M_MOVE mv;
  366.     ...
  367.     m_motion( &mv );
  368.  
  369. `co(10,1);/// m_lpen_on`co();   `keyword(source,[UW_EVENT.C]~m_lpen_on);
  370.         Turns on light pen emulation.     This is the default.
  371.  
  372. Prototype:
  373.     void m_lpen_on();
  374.  
  375. Parameters:
  376.     None.
  377.  
  378. Usage:
  379.     m_lpen_on();
  380.  
  381. `co(10,1);/// m_lpen_off`co();   `keyword(source,[UW_EVENT.C]~m_lpen_off);
  382.         Turns off light pen emulation.
  383.  
  384. Prototype:
  385.     void m_lpen_off();
  386.  
  387. Parameters:
  388.     None.
  389.  
  390. Usage:
  391.     m_lpen_off();
  392.  
  393. `co(10,1);/// m_ratio`co();   `keyword(source,[UW_EVENT.C]~m_ratio);
  394.         Sets mouse to pixel ratio.  The default values are 16 for horizontal and
  395.     8 for vertical.
  396.  
  397. Prototype:
  398.     void m_ratio( int horiz, int vert );
  399.  
  400. Parameters:
  401. `co(11,1);    int horiz, vert`co();
  402.         The values for the new horizontal and vertical ratios.
  403.  
  404. Usage:
  405.     m_ratio( 12, 8 );
  406.  
  407. `co(4,7);──────────────────────── /// The Window Manager ──────────────────────────────`co();
  408.  
  409.                                 `keyword(Introduction,/// Window Manager Introduction);
  410.  ┌──────────────────────────────────────────────────────────────────────────┐    
  411.  │      `keyword(link_window,/// link_window);             `keyword(unlink_window,/// unlink_window);         `keyword(make_top_window,/// make_top_window);       │
  412.  │      `keyword(cr_inwindow,/// cr_inwindow);             `keyword(move_wn_left,/// move_wn_left);          `keyword(move_wn_right,/// move_wn_right);         │
  413.  │      `keyword(move_wn_up,/// move_wn_up);              `keyword(move_wn_down,/// move_wn_down);          `keyword(reset_all_masks,/// reset_all_masks);       │
  414.  │      `keyword(refresh_desktop,/// refresh_desktop);         `keyword(refresh_column,/// refresh_column);        `keyword(refresh_row,/// refresh_row);           │
  415.  │      `keyword(redisplay_rect,/// redisplay_rect);                                                      │
  416.  └──────────────────────────────────────────────────────────────────────────┘
  417.  
  418. `co(4,7);────────────────────/// Window Manager Introduction ──────────────────────────`co();
  419.  
  420.         The window manager is a set of routines that make having multiple
  421.     windows on the screen at once a snap!  By using the window manager, you
  422.     bypass having to keep track of window masking and refreshing, as the
  423.     manager takes care of all the nitty gritty details of multiple overlapping
  424.     windows.    To use the manager, first create a window with `keyword(wn_create,[uw_help1.hlp]/// wn_create); that is
  425.     the size of the screen, and call `keyword(link_window,/// link_window); with that window.     This is
  426.     your background, or desktop window.  Then you may create and link any
  427.     number (limited only by the amount of memory you have in your computer) of
  428.     windows of any size, regardless of whether they overlap each other, and
  429.     output text to them using any of the window I/O routines.  At any time you
  430.     may also unlink a window from the linked list with `keyword(unlink_window,/// unlink_window);, which
  431.     removes it from the screen as well.  The link_window/unlink_window sequence
  432.     may be called as many times as you wish, with the same window created with
  433.     wn_create.  When you are finally ready to dispose of your window, simply
  434.     call unlink_window followed by `keyword(wn_destroy,[uw_help1.hlp]/// wn_destroy);.
  435.  
  436. `co(10,1);/// link_window`co();   `keyword(source,[UW_ENTRY.C]~link_window);
  437.         Takes the window created with `keyword(wn_create,[uw_help1.hlp]/// wn_create); by pointer and links it to the
  438.     window manager's linked list. The window is placed on the screen, and if
  439.     it overlaps any other window, then their masks are set to prevent output
  440.     to the area that overlaps. The window is then drawn on the video screen.
  441.  
  442. Prototype:
  443.     WINDOW *link_window( WINDOW *wnp );
  444.  
  445. Parameters:
  446. `co(11,1);    WINDOW *wnp;`co();
  447.         A pointer to the window created with wn_create.
  448.  
  449. Usage:
  450.     WINDOW wn;
  451.     ...
  452.     link_window(&wn);
  453.  
  454. `co(10,1);/// unlink_window`co();   `keyword(source,[UW_WIN.C]~unlink_window);
  455.         Takes the window by pointer, removes it from the linked list, resets any
  456.     window's masks that were overlapped, and redraws any portion of any window
  457.     that was covered by the window.  This is the complement to `keyword(link_window,/// link_window);.
  458.     After calling `keyword(wn_create,[uw_help1.hlp]/// wn_create);, you may call link_window and unlink_window as many
  459.     times as you wish.  When you wish to finally free the memory used by the
  460.     window, simply unlink the window from the list with unlink_window and call
  461.   `keyword(wn_destroy,[uw_help1.hlp]/// wn_destroy);.
  462.  
  463. Prototype:
  464.     int unlink_window( WINDOW *wnp );
  465.  
  466. Parameters:
  467. `co(11,1);    WINDOW *wnp;`co();
  468.         A pointer to the window to unlink.
  469.  
  470. Usage:
  471.     WINDOW wn;
  472.     ...
  473.     wn_create( 0, 0, 79, 24, SGL_BDR, WN_NORMAL, wnp );
  474.     link_window(&wn);
  475.     ...
  476.     unlink_window(&wn);
  477.     wn_destroy(&wn);
  478.  
  479. `co(10,1);/// make_top_window`co();   `keyword(source,[UW_WIN.C]~make_top_window);
  480.         Takes a pointer to the window, and makes it the top window.  All
  481.     adjustments to the masks of all windows are made, and the window is drawn
  482.     to the screen.
  483.  
  484. Prototype:
  485.     int make_top_window( WINDOW *wnp );
  486.  
  487. Parameters:
  488. `co(11,1);    WINDOW *wnp;`co();
  489.         A pointer to the window to bring to the top.
  490.  
  491. Usage:
  492.     WINDOW *wnp;
  493.     ...
  494.     make_top_window(wnp);
  495.  
  496. `co(10,1);/// cr_inwindow`co();   `keyword(source,[UW_WIN.C]~cr_inwindow);
  497.         Takes a location on the screen, and returns the topmost window that
  498.     contains that location.  If there is no window under the location, then a
  499.     NULL is returned.
  500.  
  501. Prototype:
  502.     WINDOW *cr_inwindow( int col, int row )
  503.  
  504. Parameters:
  505. `co(11,1);    int col, row`co();
  506.         The col,row coordinate (x,y) to check.
  507.  
  508. Usage:
  509.     WINDOW *wnp;
  510.     ...
  511.     wnp = cr_inwindow( 20, 37 );
  512.  
  513. `co(10,1);/// move_wn_left`co();   `keyword(source,[UW_WIN.C]~move_wn_left);
  514.         Takes a window in the manager's linked list, and moves it smoothly to
  515.     the left a given number of columns.
  516.  
  517. Prototype:
  518.     void move_wn_left( int cols, WINDOW *wnp );
  519.  
  520. Parameters:
  521. `co(11,1);    int cols`co();
  522.         The number of columns to move left.
  523. `co(11,1);    WINDOW *wnp;`co();
  524.         A pointer to the window to move.
  525.  
  526. Usage:
  527.     WINDOW *wnp;
  528.     ...
  529.     move_wn_left( 3, wnp );
  530.  
  531. `co(10,1);/// move_wn_right`co();   `keyword(source,[UW_WIN.C]~move_wn_right);
  532.         Takes a window in the manager's linked list, and moves it smoothly to
  533.     the right a given number of columns.
  534.  
  535. Prototype:
  536.     void move_wn_right( int cols, WINDOW *wnp );
  537.  
  538. Parameters:
  539. `co(11,1);    int cols`co();
  540.         The number of columns to move right.
  541. `co(11,1);    WINDOW *wnp;`co();
  542.         A pointer to the window to move.
  543.  
  544. Usage:
  545.     WINDOW *wnp;
  546.     ...
  547.     move_wn_right( 2, wnp );
  548.  
  549. `co(10,1);/// move_wn_up`co();   `keyword(source,[UW_WIN.C]~move_wn_up);
  550.         Takes a window in the manager's linked list, and moves it smoothly up a
  551.     given number of rows.
  552.  
  553. Prototype:
  554.     void move_wn_up( int rows, WINDOW *wnp );
  555.  
  556. Parameters:
  557. `co(11,1);    int rows`co();
  558.         The number of rows to move up.
  559. `co(11,1);    WINDOW *wnp;`co();
  560.         A pointer to the window to move.
  561.  
  562. Usage:
  563.     WINDOW *wnp;
  564.     ...
  565.     move_wn_up( 1, wnp );
  566.  
  567. `co(10,1);/// move_wn_down`co();   `keyword(source,[UW_WIN.C]~move_wn_down);
  568.         Takes a window in the manager's linked list, and moves it smoothly down
  569.     a given number of rows.
  570.  
  571. Prototype:
  572.     void move_wn_down( int rows, WINDOW *wnp );
  573.  
  574. Parameters:
  575. `co(11,1);    WINDOW *wnp;`co();
  576.         A pointer to the window to move.
  577. `co(11,1);    int rows`co();
  578.         The number of rows to move down.
  579.  
  580. Usage:
  581.     WINDOW *wnp;
  582.     ...
  583.     move_wn_down( 1, wnp );
  584.  
  585. `co(10,1);/// reset_all_masks`co();   `keyword(source,[UW_WIN.C]~reset_all_masks);
  586.     Walks through all the windows in the manager's linked list, and resets
  587.     their output masks so that only the visible areas of the windows are
  588.     modified during window output.  Calling this function is not necessary
  589.     unless you adjust a window's mask yourself, and want to set all window
  590.     masks back to their default state. 
  591.  
  592. Prototype:
  593.     void reset_all_masks();
  594.  
  595. Parameters:
  596.     None.
  597.  
  598. Usage:
  599.     reset_all_masks();
  600.  
  601. `co(10,1);/// refresh_desktop`co();   `keyword(source,[UW_WIN.C]~refresh_desktop);
  602.         Walks through the linked list of windows and redraws each. This is a
  603.     quick way to redisplay the screen.  It can be useful when returning from
  604.     executing another program, returning from graphics mode, etc...
  605.  
  606. Prototype:
  607.     void refresh_desktop(void);
  608.  
  609. Parameters:
  610.     None
  611.  
  612. Usage:
  613.     refresh_desktop();
  614.  
  615. `co(10,1);/// refresh_column`co();   `keyword(source,[UW_WIN.C]~refresh_column);
  616.         Walks through the linked list of windows and checks to see if each
  617.     window contains a particular column.     If the window contains the column,
  618.     then only that column is refreshed.  This function is used internally by
  619.     wn_move_left and wn_move_right.
  620.         
  621. Prototype:
  622.     void refresh_column( int col )
  623.  
  624. Parameters:
  625. `co(11,1);    int col`co();
  626.         The column to refresh (redraw).
  627.  
  628. Usage:
  629.     refresh_column( 20 );
  630.  
  631. `co(10,1);/// refresh_row`co();   `keyword(source,[UW_WIN.C]~refresh_row);
  632.         Walks through the linked list of windows and checks to see if each
  633.     window contains a particular row.     If the window contains the row, then
  634.     only that row is refreshed.  This function is used internally by
  635.     wn_move_up and wn_move_down.
  636.         
  637. Prototype:
  638.     void refresh_row( int row )
  639.  
  640. Parameters:
  641. `co(11,1);    int row`co();
  642.         The row to refresh (redraw).
  643.  
  644. Usage:
  645.     refresh_row( 5 );
  646.  
  647. `co(10,1);/// redisplay_rect`co();   `keyword(source,[UW_WIN.C]~redisplay_rect);
  648.         Refreshes a rectangular portion of the manager's screen, defined by a
  649.     variable of type RECT.  The window manager calls this function when a
  650.     window is unlinked with unlink_window. The window's pane is used as the
  651.     rectangular area passed.
  652.  
  653.     NOTE: Use the set_rect function to define a variable of type RECT.
  654.  
  655. Prototype:
  656.     void redisplay_rect( RECT *rectp );
  657.  
  658. Parameters:
  659. `co(11,1);    RECT *rectp`co();
  660.         A pointer to the rectangular area to display.
  661.  
  662. Usage:
  663.     RECT r;
  664.     ...
  665.     redisplay_rect( &r );
  666.